// dishes.js
const app = getApp()

Page({
  data: {
    searchKeyword: '',
    categories: [
      { id: 'all', name: '', icon: '🍽️' },
      { id: 'main', name: '', icon: '🍖' },
      { id: 'side', name: '', icon: '🥬' },
      { id: 'dessert', name: '', icon: '🍰' },
      { id: 'drink', name: '', icon: '🥤' },
      { id: 'combo', name: '', icon: '🍱' }
    ],
    selectedCategory: 'all',
    dishes: [],
    filteredDishes: [],
    availableDishesCount: 0,
    soldDishesCount: 0,
    cartItemCount: 0,
    scrollIntoView: '', // 用于滚动定位
    // 购物车拖动相关状态
    isDragging: false,
    cartPosition: { x: 0, y: 0 },
    dragStartPosition: { x: 0, y: 0 },
    screenSize: { width: 0, height: 0 },
    // 弹框相关状态
    showDetailModal: false,
    currentDish: {}
  },

  onLoad() {
    // 注册页面实例，用于接收服务数据变化通知
    app.registerPage(this)
    
    // 监听服务数据变化事件
    if (app.globalData.eventBus) {
      app.globalData.eventBus.on('dishesDataChanged', this.onDishesDataChanged.bind(this))
      // 监听显示服务详情事件
      app.globalData.eventBus.on('showDishDetail', this.onShowDishDetail.bind(this))
    }
    
    this.loadDishes()
    this.updateCartCount()
    
    // 获取屏幕尺寸并设置购物车初始位置
    this.initCartPosition()
    
    // 延迟检查购物车位置
    setTimeout(() => {
      console.log('购物车当前位置:', this.data.cartPosition)
      console.log('购物车是否显示:', this.data.cartItemCount > 0)
    }, 1000)
  },

  onUnload() {
    // 注销页面实例
    app.unregisterPage(this)
    
    // 取消事件监听
    if (app.globalData.eventBus) {
      app.globalData.eventBus.off('dishesDataChanged', this.onDishesDataChanged.bind(this))
      app.globalData.eventBus.off('showDishDetail', this.onShowDishDetail.bind(this))
    }
  },

  onShow() {
    this.updateCartCount()
    
    // 检查服务数据是否有更新
    this.checkDishesDataUpdate()
    
    // 延迟刷新，确保数据同步
    setTimeout(() => {
      this.updateCartCount()
      this.updateDishQuantities()
      // 重新筛选服务，确保数量正确
      this.filterDishes()
      
      // 检查是否需要显示服务详情
      this.checkShowDishDetail()
    }, 200)
    
    // 初始化TabBar页面（检查并应用等待中的图标配置）
    app.initTabBarPage()
  },

  // 检查服务数据更新
  checkDishesDataUpdate() {
    const dishesLastUpdated = wx.getStorageSync('dishesLastUpdated')
    const dishesDataChanged = wx.getStorageSync('dishesDataChanged')
    const forceSyncDishes = wx.getStorageSync('forceSyncDishes')
    const syncTimestamp = wx.getStorageSync('syncTimestamp')
    
    if (dishesDataChanged && dishesLastUpdated) {
      console.log('检测到服务数据更新，重新加载数据')
      
      // 清除更新标志
      wx.removeStorageSync('dishesDataChanged')
      
      // 重新加载服务数据
      this.loadDishes()
      
      // 显示更新提示
      // wx.showToast({
      //   title: '服务数据已更新',
      //   icon: 'success',
      //   duration: 1500
      // })
    }
    
    // 检查强制同步标志
    if (forceSyncDishes && syncTimestamp) {
      console.log('检测到强制同步标志，立即同步数据')
      
      // 清除强制同步标志
      wx.removeStorageSync('forceSyncDishes')
      wx.removeStorageSync('syncTimestamp')
      
      // 立即重新加载服务数据
      this.loadDishes()
      
      // 显示同步提示
      // wx.showToast({
      //   title: '服务数据已同步',
      //   icon: 'success',
      //   duration: 1500
      // })
    }
  },

  // 服务数据变化回调（由app.js调用）
  onDishesDataChanged(dishes) {
    console.log('收到服务数据变化通知:', dishes)
    
    // 立即更新服务数据
    this.setData({
      dishes: dishes.map(dish => ({
        ...dish,
        soldCount: Math.floor(Math.random() * 50) + 10,
        cartQuantity: this.getCartQuantity(dish._id || dish.id)
      })),
      availableDishesCount: dishes.filter(dish => dish.available).length,
      soldDishesCount: dishes.reduce((sum, dish) => sum + (dish.soldCount || 0), 0)
    })
    
    // 重新筛选服务
    this.filterDishes()
    
    // 显示更新提示
    // wx.showToast({
    //   title: '服务数据已同步',
    //   icon: 'success',
    //   duration: 1500
    // })
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.loadDishes()
    this.updateCartCount()
    wx.stopPullDownRefresh()
  },

  // 加载服务数据
  loadDishes() {
    // 确保服务数据已同步
    app.syncDishesData()
    
    const appData = app.globalData
    const dishes = appData.dishes.map(dish => ({
      ...dish,
      // 确保使用统一的ID字段
      _id: dish._id || dish.id,
      id: dish._id || dish.id, // 保持向后兼容
      available: dish.available !== undefined ? dish.available : true,
      price: dish.price || 0,
      soldCount: Math.floor(Math.random() * 50) + 10, // 模拟销量数据
      image: dish.image || app.getDefaultDishImage(dish.category), // 使用app的统一方法
      cartQuantity: this.getCartQuantity(dish._id || dish.id) // 添加购物车数量字段
    }))
    
    console.log('加载的服务数据:', dishes)
    console.log('可用服务数量:', dishes.filter(dish => dish.available).length)
    
    this.setData({
      dishes,
      availableDishesCount: dishes.filter(dish => dish.available).length,
      soldDishesCount: dishes.reduce((sum, dish) => sum + dish.soldCount, 0)
    })
    
    this.filterDishes()
  },

  // 根据分类获取默认图片（现在使用app的统一方法）
  getDefaultImage(category) {
    return app.getDefaultDishImage(category)
  },

  // 处理图片加载错误
  onImageError(e) {
    const dishId = e.currentTarget.dataset.id
    const dishes = this.data.dishes.map(dish => {
      if (dish.id === dishId) {
        return { ...dish, image: '/images/dishes/hongshao_rou.jpg' }
      }
      return dish
    })
    
    this.setData({ dishes })
    this.filterDishes()
  },

  // 搜索输入
  onSearchInput(e) {
    this.setData({
      searchKeyword: e.detail.value
    })
    this.filterDishes()
  },

  // 筛选服务
  filterDishes() {
    let filtered = this.data.dishes
    
    // 按分类筛选
    if (this.data.selectedCategory !== 'all') {
      const categoryMap = {
        'main': '大菜',
        'side': '小菜',
        'dessert': '茶点',
        'drink': '饮品',
        'combo': '套餐'
      }
      filtered = filtered.filter(dish => dish.category === categoryMap[this.data.selectedCategory])
    }
    
    // 按关键词搜索
    if (this.data.searchKeyword) {
      const keyword = this.data.searchKeyword.toLowerCase()
      filtered = filtered.filter(dish => 
        dish.name.toLowerCase().includes(keyword) || 
        dish.desc.toLowerCase().includes(keyword) ||
        dish.category.toLowerCase().includes(keyword)
      )
    }
    
    // 确保筛选后的服务包含最新的购物车数量
    filtered = filtered.map(dish => ({
      ...dish,
      cartQuantity: this.getCartQuantity(dish._id)
    }))
    
    this.setData({
      filteredDishes: filtered
    })
  },

  // 选择分类
  selectCategory(e) {
    const categoryId = e.currentTarget.dataset.id
    this.setData({
      selectedCategory: categoryId
    })
    this.filterDishes()
    
    // 滚动到分类顶部
    this.scrollToCategoryTop()
  },

  // 滚动到分类顶部
  scrollToCategoryTop() {
    this.setData({
      scrollIntoView: 'category-header'
    })
    
    // 重置滚动位置
    setTimeout(() => {
      this.setData({
        scrollIntoView: ''
      })
    }, 100)
  },

  // 获取分类名称
  getCategoryName(categoryId) {
    if (categoryId === 'all') return '全部服务'
    
    const category = this.data.categories.find(cat => cat.id === categoryId)
    return category ? category.name : '全部服务'
  },

  // 增加数量
  increaseQuantity(e) {
    const dishId = e.currentTarget.dataset.id
    
    const dish = this.data.dishes.find(d => d._id === dishId)
    
    if (dish && dish.available) {
      // 添加到购物车
      app.addToCart(dish, 1)
      
      // 直接更新对应服务的数量
      this.updateDishQuantity(dishId)
      this.updateCartCount()
      
      // 显示添加成功提示
      // wx.showToast({
      //   title: '已添加',
      //   icon: 'success',
      //   duration: 1000
      // })
    } else {
      console.error('服务不存在或不可用:', { dishId, dish, available: dish?.available })
    }
  },

  // 直接加入购物车
  addToCart(e) {
    const dishId = e.currentTarget.dataset.id
    
    const dish = this.data.dishes.find(d => d._id === dishId)
    
    if (dish && dish.available) {
      // 添加到购物车
      app.addToCart(dish, 1)
      
      // 直接更新对应服务的数量
      this.updateDishQuantity(dishId)
      this.updateCartCount()
      
      // 显示添加成功提示
      wx.showToast({
        title: '已添加',
        icon: 'success',
        duration: 1000
      })
    } else {
      console.error('服务不存在或不可用:', { dishId, dish, available: dish?.available })
    }
  },

  // 减少数量
  decreaseQuantity(e) {
    const dishId = e.currentTarget.dataset.id
    
    // 从购物车移除一个
    app.removeFromCart(dishId)
    
    // 直接更新对应服务的数量
    this.updateDishQuantity(dishId)
    this.updateCartCount()
    
    // 显示移除成功提示
    wx.showToast({
      title: '已从购物车移除',
      icon: 'success',
      duration: 1000
    })
  },

  // 更新购物车数量
  updateCartCount() {
    const cart = app.globalData.cart || []
    const cartItemCount = cart.reduce((sum, item) => sum + item.quantity, 0)
    
    this.setData({
      cartItemCount
    })
  },

  // 获取购物车中指定服务的数量
  getCartQuantity(dishId) {
    const cart = app.globalData.cart || []
    
    const cartItem = cart.find(item => {
      const itemId = item._id || item.id
      return itemId === dishId
    })
    
    return cartItem ? cartItem.quantity : 0
  },

  // 更新单个服务的数量
  updateDishQuantity(dishId) {
    // 获取当前购物车中该服务的数量
    const newQuantity = this.getCartQuantity(dishId)
    
    // 更新dishes数组中对应服务的数量
    const dishes = this.data.dishes.map(dish => {
      if (dish._id === dishId) {
        return { ...dish, cartQuantity: newQuantity }
      }
      return dish
    })
    
    // 同时更新filteredDishes
    const filteredDishes = this.data.filteredDishes.map(dish => {
      if (dish._id === dishId) {
        return { ...dish, cartQuantity: newQuantity }
      }
      return dish
    })
    
    this.setData({
      dishes,
      filteredDishes
    })
  },

  // 更新所有服务的数量显示（保留用于页面刷新时）
  updateDishQuantities() {
    // 更新每个服务的购物车数量
    const updatedDishes = this.data.dishes.map(dish => ({
      ...dish,
      cartQuantity: this.getCartQuantity(dish._id)
    }))
    
    // 同时更新filteredDishes
    const updatedFilteredDishes = this.data.filteredDishes.map(dish => ({
      ...dish,
      cartQuantity: this.getCartQuantity(dish._id)
    }))
    
    this.setData({
      dishes: updatedDishes,
      filteredDishes: updatedFilteredDishes
    })
  },

  // 查看购物车
  viewCart() {
    wx.switchTab({
      url: '/pages/cart/cart'
    })
  },



  // 服务详情
  viewDishDetail(e) {
    const dishId = e.currentTarget.dataset.id
    const dish = this.data.dishes.find(d => d.id === dishId)
    
    if (dish) {
      wx.showModal({
        title: dish.name,
        content: `${dish.desc}\n\n分类：${dish.category}\n状态：${dish.available ? '可点' : '已售完'}`,
        showCancel: false,
        confirmText: '知道了'
      })
    }
  },

  // 初始化购物车位置
  initCartPosition() {
    const systemInfo = wx.getSystemInfoSync()
    const screenWidth = systemInfo.screenWidth
    const screenHeight = systemInfo.screenHeight
    
    // 设置购物车初始位置（右下角，避开tabbar）
    // tabbar高度大约100px，购物车尺寸50px
    const cartSize = 50 // 购物车尺寸改为50px
    const tabbarHeight = 100 // tabbar高度
    const margin = 20 // 边距
    
    const initialX = screenWidth - cartSize - margin // 距离右边缘20px
    const initialY = screenHeight - tabbarHeight - cartSize - margin - 120 // 距离tabbar顶部140px，更靠上
    
    // 确保位置在合理范围内
    const safeX = Math.max(20, Math.min(initialX, screenWidth - cartSize - 20))
    const safeY = Math.max(20, Math.min(initialY, screenHeight - tabbarHeight - cartSize - 20))
    
    this.setData({
      screenSize: {
        width: screenWidth,
        height: screenHeight
      },
      cartPosition: {
        x: safeX,
        y: safeY
      }
    })
    
    console.log('购物车初始位置:', { safeX, safeY, screenWidth, screenHeight, tabbarHeight })
  },

  // 触摸开始
  onTouchStart(e) {
    console.log('触摸开始:', e.touches[0])
    
    // 记录触摸开始时间和位置
    this.touchStartTime = Date.now()
    this.touchStartPosition = {
      x: e.touches[0].clientX,
      y: e.touches[0].clientY
    }
    
    // 延迟设置拖动状态，避免误触
    this.longPressTimer = setTimeout(() => {
      this.setData({
        isDragging: true
      })
      console.log('长按触发，开始拖动模式')
    }, 300) // 300ms后触发长按
  },

  // 触摸移动（实时处理，提高跟手性）
  onTouchMove(e) {
    if (!this.data.isDragging) return
    
    const touch = e.touches[0]
    const currentTime = Date.now()
    
    // 检查是否达到长按时间阈值（300ms）
    if (currentTime - this.touchStartTime < 300) {
      return
    }
    
    // 检查触摸移动距离是否足够（防止误触）
    const moveDistance = Math.sqrt(
      Math.pow(touch.clientX - this.touchStartPosition.x, 2) + 
      Math.pow(touch.clientY - this.touchStartPosition.y, 2)
    )
    
    if (moveDistance < 5) { // 降低移动距离阈值，提高灵敏度
      return
    }
    
    // 直接使用触摸点位置，让购物车跟随手指移动
    const newX = touch.clientX - 25 // 购物车中心跟随触摸点，25px是购物车半径
    const newY = touch.clientY - 25 // 购物车中心跟随触摸点，25px是购物车半径
    
    // 限制购物车在屏幕范围内，避开tabbar
    const cartSize = 50 // 购物车尺寸50px
    const tabbarHeight = 100 // tabbar高度
    const maxX = this.data.screenSize.width - cartSize - 20 // 距离右边缘20px
    const maxY = this.data.screenSize.height - tabbarHeight - cartSize - 20 - 120 // 距离tabbar顶部140px，更靠上
    
    const clampedX = Math.max(20, Math.min(newX, maxX)) // 最小距离左边缘20px
    const clampedY = Math.max(20, Math.min(newY, maxY)) // 最小距离顶部20px
    
    this.setData({
      cartPosition: {
        x: clampedX,
        y: clampedY
      }
    })
    
    console.log('拖动中:', { newX, newY, clampedX, clampedY, maxY, moveDistance })
  },

  // 触摸结束
  onTouchEnd(e) {
    console.log('触摸结束')
    
    // 清理长按定时器
    if (this.longPressTimer) {
      clearTimeout(this.longPressTimer)
      this.longPressTimer = null
    }
    
    // 如果不是拖动状态，则执行点击事件
    if (!this.data.isDragging) {
      this.viewCart()
      return
    }
    
    // 结束拖动
    this.endDrag()
  },

  // 触摸取消
  onTouchCancel(e) {
    console.log('触摸取消')
    
    // 清理长按定时器
    if (this.longPressTimer) {
      clearTimeout(this.longPressTimer)
      this.longPressTimer = null
    }
    
    // 重置拖动状态
    this.setData({
      isDragging: false
    })
  },

  // 结束拖动
  endDrag() {
    console.log('结束拖动，最终位置:', this.data.cartPosition)
    this.setData({
      isDragging: false
    })
  },

  // 显示服务详情弹框
  showDishDetail(e) {
    const dish = e.currentTarget.dataset.dish
    console.log('显示服务详情:', dish)
    
    this.setData({
      showDetailModal: true,
      currentDish: dish
    })
  },

  // 关闭服务详情弹框
  closeDishDetail() {
    this.setData({
      showDetailModal: false,
      currentDish: {}
    })
  },

  // 阻止事件冒泡
  stopPropagation() {
    return false
  },

  // 从详情弹框减少数量
  decreaseQuantityFromDetail(e) {
    const dishId = e.currentTarget.dataset.id
    this.decreaseQuantity(e)
    
    // 更新弹框中的数量显示
    this.updateDetailModalQuantity(dishId)
  },

  // 从详情弹框增加数量
  increaseQuantityFromDetail(e) {
    const dishId = e.currentTarget.dataset.id
    this.increaseQuantity(e)
    
    // 更新弹框中的数量显示
    this.updateDetailModalQuantity(dishId)
  },

  // 从详情弹框加入购物车
  addToCartFromDetail(e) {
    const dishId = e.currentTarget.dataset.id
    const dish = this.data.currentDish
    
    if (dish && dish.available) {
      // 如果数量为0，先设置为1
      if (!dish.cartQuantity || dish.cartQuantity === 0) {
        this.increaseQuantity({ currentTarget: { dataset: { id: dishId } } })
      }
      
      wx.showToast({
        title: '已添加',
        icon: 'success'
      })
      
      // 关闭弹框
      this.closeDishDetail()
    }
  },

  // 更新弹框中的数量显示
  updateDetailModalQuantity(dishId) {
    const dish = this.data.dishes.find(d => d._id === dishId)
    if (dish) {
      this.setData({
        'currentDish.cartQuantity': dish.cartQuantity || 0
      })
    }
  },

  // 检查是否需要显示服务详情
  checkShowDishDetail() {
    const dishToShow = app.globalData.dishToShowDetail
    if (dishToShow) {
      console.log('检测到需要显示服务详情:', dishToShow)
      
      // 在本地服务数据中查找对应的服务
      const localDish = this.data.dishes.find(d => 
        (d._id === dishToShow._id) || (d.id === dishToShow.id)
      )
      
      if (localDish) {
        console.log('找到本地服务数据，显示详情:', localDish)
        // 显示服务详情弹框
        this.setData({
          showDetailModal: true,
          currentDish: localDish
        })
        
        // 清除全局数据，避免重复显示
        app.globalData.dishToShowDetail = null
      } else {
        console.log('未找到本地服务数据，等待数据加载完成')
        // 如果本地数据还没加载完成，延迟检查
        setTimeout(() => {
          this.checkShowDishDetail()
        }, 500)
      }
    }
  },

  // 处理显示服务详情事件
  onShowDishDetail(dish) {
    console.log('收到显示服务详情事件:', dish)
    
    // 延迟执行，确保页面已完全加载
    setTimeout(() => {
      this.checkShowDishDetail()
    }, 300)
  }
}) 